// 数据解析
export function analysisData(confingValue) {
  let configData = {
    apltable: '', // 申请表
    enttable: '', // 企业表
    span: 2, // 一行多少个
    fill_item: [], // 渲染项
    rules: {}, // 校验规则
    paragraph: {}, // 小标题
    expression: {}, // 响应式
    filter: {}, // 过滤条件
  }
  let result = {
    status: false,
    value: configData
  }
  try {
    configData.apltable = confingValue.apltable
    configData.enttable = confingValue.enttable
    configData.must = confingValue.must
    let fill_item_temp = []
    let maprelation = {}
    for (let v of confingValue.mapping) {
      // 绑定字段缺失不处理
      if (!v.b) {
        continue
      }
      maprelation[v.t] = v.b
      let tempObj = {
        field: v.t,
        // datalength: 0, // 字段长度
        describe: v.comments, // 字段描述
        // type: '', // 类型
        // enum: '', // 枚举值
        isnull: v.isRequired, // 是否必填
        hidden: v.hidden, // 是否隐藏
        disable: v.disable, // 是否禁用
        defaultValue: v.default || null,
        // paragname: '', // 段落小标题
        // precision: '', // 精度 数字输入框
        // ismultiple: false, // 是否多选
      }
      // 1 校验规则
      let rulesTempArr = []
      if (v.t in configData.rules) {
        rulesTempArr = configData.rules[v.t]
      }
      // 1.1 必填
      if (v.isRequired) {
        if (v.type == 'input') {
          rulesTempArr.push({
            required: true,
            message: `${v.comments}不能为空`,
            trigger: 'change',
            pattern: '[^\\s\\r\\n]',
          })
        } else {
          rulesTempArr.push({
            required: true,
            message: `${v.comments}不能为空`,
            trigger: 'change',
          })
        }
      }
      // 1.2 自定义校验规则
      if (v.attributeValue.rules.length > 0) {
        v.attributeValue.rules.forEach((r) => {
          rulesTempArr.push({
            message: r.message,
            trigger: 'blur',
            pattern: r.regexp,
          })
        })
      }
      // 2. 过滤条件
      // console.log('v.attributeValue', v.attributeValue)
      if (v.attributeValue.filters.length > 0) {
        v.attributeValue.filters.forEach((f) => {
          configData.filter[f.field] = f.value
        })
      }
      // console.log('过滤条件', configData.filter)
      configData.rules[v.t] = rulesTempArr
      // 3. 小标题
      if (v.isLable) {
        configData.paragraph[v.t] = v.attributeValue.lable
      }
      // 4. 响应式
      if (v.isExpression) {
        configData.expression[v.t] = v.attributeValue.expression
      }
      // 5. 配置控件属性
      tempObj.type = v.type
      if (['textarea', 'input'].includes(v.type)) {
        tempObj.datalength = v.attributeValue.maxLength
      } else if (v.type == 'number') {
        tempObj.precision = v.attributeValue.precision
        tempObj.minValue = v.attributeValue.minValue
        tempObj.maxValue = v.attributeValue.maxValue
      } else if (['select', 'tree', 'checkbox', 'radio' ].includes(v.type)) {
        tempObj.enum = v.attributeValue.enum
        tempObj.ismultiple = v.attributeValue.ismultiple
      } else if (v.type == 'file') {
        tempObj.maxFile = v.attributeValue.maxFile
      } else if (v.type == 'cascader') {
        tempObj.range = v.attributeValue.range
      } else if (v.type == 'date') {
        tempObj.format = v.attributeValue.format
      }
      // 按行数组装
      fill_item_temp.push(tempObj)
    }
    recursion_splice(configData.span, fill_item_temp, configData.fill_item)
    console.log('解析数据完成', result)
    result.status = true
    result.value.maprelation = maprelation
    return result
  } catch (error) {
    console.error('解析数据失败', error)
    return result
  }
}

// 表格解析
export function analysisTable(confingValue) {
  let columns = []
  let slot_list = []
  let result = {
    status: false,
    columns: columns,
    slot_list: slot_list,
    apltable: confingValue.apltable,
    enttable: confingValue.enttable
  }
  let maprelation = {}
  try {
    columns.push({
      title: '序号',
      width: '65px',
      height: '50px',
      fixed: 'left',
      scopedSlots: {
        customRender: 'serial'
      },
    })
    for (let v of confingValue.mapping) {
      // 绑定字段缺失不处理
      if (!v.b) {
        continue
      }
      maprelation[v.t] = v.b
      let tempItem = {
        field: v.t,
        describe: v.comments,
        isnull: v.isRequired, // 是否必填
        slot: v.t + 'Slot'
      }
      tempItem.type = v.type
      if (v.type == 'input') {
        tempItem.datalength = v.attributeValue.maxLength
      } else if (v.type == 'number') {
        tempItem.precision = v.attributeValue.precision
        tempItem.minValue = v.attributeValue.minValue
        tempItem.maxValue = v.attributeValue.maxValue
      } else if (v.type == 'select') {
        tempItem.enum = v.attributeValue.enum
        tempItem.ismultiple = v.attributeValue.ismultiple
      } else if (v.type == 'file') {
        tempItem.maxFile = v.attributeValue.maxFile
      }
      // 添加子表格配置
      columns.push({
        title: v.comments,
        dataIndex: v.t,
        width: '1',
        align: 'left',
        scopedSlots: {
          customRender: tempItem.slot
        },
      })
      // 新增插槽初始化
      slot_list.push(tempItem)
    }
    if (columns.length > 5) {
      columns.forEach(v => {
        if (v.width == '1') {
          v.width = '200px'
        }
      })
    }
    columns.push({
      title: '操作',
      dataIndex: 'action',
      width: '65px',
      fixed: 'right',
      scopedSlots: {
        customRender: 'operation'
      },
    })
    result.status = true
    result.maprelation = maprelation
    console.log('解析表格成功', result)
    return result
  } catch (error) {
    console.log('解析表格失败', error)
  }
}

// 递归, 按两个一组
function recursion_splice(span, spanArr, tempArr) {
  if (spanArr.length > span) {
    tempArr.push(spanArr.splice(0, span))
    if (spanArr.length > span) {
      recursion_splice(span, spanArr, tempArr)
    } else {
      if (spanArr.length > 0) {
        tempArr.push(spanArr)
      }
      return
    }
  } else {
    tempArr.push(spanArr)
  }
}